#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Excel to JSON Converter
支持灵活的输出选项和自定义源文件
"""

import pandas as pd
import json
import os
import argparse
import sys
from datetime import datetime
from pathlib import Path


def setup_args():
    """设置命令行参数"""
    parser = argparse.ArgumentParser(
        description='Convert Excel file to JSON format with flexible output options',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog='''
Examples:
  python convert_excel_to_json.py                          # 交互式模式
  python convert_excel_to_json.py -f data_job.xlsx -a      # 生成所有格式
  python convert_excel_to_json.py -f data_job.xlsx -c      # 只生成完整数据
  python convert_excel_to_json.py -f data_job.xlsx -s      # 只生成单独文件
  python convert_excel_to_json.py -f data_job.xlsx -m      # 只生成带元数据文件
  python convert_excel_to_json.py -f data_job.xlsx -o custom_output_dir
        '''
    )
    
    parser.add_argument('-f', '--file', 
                       help='Excel源文件路径 (默认: data_job.xlsx)')
    parser.add_argument('-o', '--output', 
                       default='data/job_info',
                       help='输出目录 (默认: data/job_info)')
    
    # 输出格式选项
    output_group = parser.add_mutually_exclusive_group()
    output_group.add_argument('-a', '--all', action='store_true',
                            help='生成所有格式文件')
    output_group.add_argument('-c', '--complete', action='store_true',
                            help='只生成完整数据文件 (job_data.json)')
    output_group.add_argument('-s', '--separate', action='store_true',
                            help='只生成单独职位文件 (job_0.json, job_1.json, ...)')
    output_group.add_argument('-m', '--metadata', action='store_true',
                            help='只生成带元数据文件 (job_data_with_metadata.json)')
    
    parser.add_argument('--no-readme', action='store_true',
                       help='不生成README.md文件')
    parser.add_argument('--indent', type=int, default=2,
                       help='JSON缩进空格数 (默认: 2)')
    
    return parser


def interactive_mode():
    """交互式模式"""
    print("=== Excel to JSON 转换器 ===\n")
    
    # 选择源文件
    print("1. 选择源文件:")
    default_file = "data_job.xlsx"
    source_file = input(f"   请输入Excel文件路径 (默认: {default_file}): ").strip()
    if not source_file:
        source_file = default_file
    
    # 检查文件是否存在
    if not os.path.exists(source_file):
        print(f"   错误: 文件 '{source_file}' 不存在！")
        return None, None, None
    
    # 选择输出目录
    print("\n2. 选择输出目录:")
    default_output = "data/job_info"
    output_dir = input(f"   请输入输出目录 (默认: {default_output}): ").strip()
    if not output_dir:
        output_dir = default_output
    
    # 选择输出格式
    print("\n3. 选择输出格式:")
    print("   1) 完整数据文件 (job_data.json)")
    print("   2) 单独职位文件 (job_0.json, job_1.json, ...)")
    print("   3) 带元数据文件 (job_data_with_metadata.json)")
    print("   4) 所有格式")
    
    while True:
        choice = input("   请选择 (1-4): ").strip()
        if choice in ['1', '2', '3', '4']:
            break
        print("   请输入有效选择 (1-4)")
    
    format_options = {
        '1': {'complete': True},
        '2': {'separate': True},
        '3': {'metadata': True},
        '4': {'all': True}
    }
    
    # 是否生成README
    print("\n4. 其他选项:")
    generate_readme = input("   是否生成README.md文件? (Y/n): ").strip().lower()
    generate_readme = generate_readme != 'n'
    
    return source_file, output_dir, format_options[choice], generate_readme


def convert_data_types(df):
    """转换数据类型以便JSON序列化"""
    def convert_value(val):
        if pd.isna(val):
            return None
        elif isinstance(val, (pd.Timestamp, datetime)):
            return val.strftime('%Y-%m-%d %H:%M:%S')
        elif hasattr(val, 'item'):  # numpy types
            return val.item()
        else:
            return val
    
    # 使用map代替已弃用的applymap
    if hasattr(df, 'map'):
        return df.map(convert_value)
    else:
        return df.applymap(convert_value)


def save_complete_data(data, output_dir, indent=2):
    """保存完整数据文件"""
    file_path = os.path.join(output_dir, 'job_data.json')
    with open(file_path, 'w', encoding='utf-8') as f:
        json.dump(data, f, ensure_ascii=False, indent=indent)
    print(f"✓ 已生成完整数据文件: {file_path}")
    return file_path


def save_separate_files(data, output_dir, indent=2):
    """保存单独职位文件"""
    file_paths = []
    for i, job in enumerate(data):
        file_path = os.path.join(output_dir, f'job_{i}.json')
        with open(file_path, 'w', encoding='utf-8') as f:
            json.dump(job, f, ensure_ascii=False, indent=indent)
        file_paths.append(file_path)
    print(f"✓ 已生成 {len(file_paths)} 个单独职位文件")
    return file_paths


def save_metadata_file(data, source_file, output_dir, column_names, indent=2):
    """保存带元数据的文件"""
    metadata = {
        'conversion_time': datetime.now().isoformat(),
        'source_file': os.path.basename(source_file),
        'total_records': len(data),
        'columns': column_names,
        'data': data
    }
    
    file_path = os.path.join(output_dir, 'job_data_with_metadata.json')
    with open(file_path, 'w', encoding='utf-8') as f:
        json.dump(metadata, f, ensure_ascii=False, indent=indent)
    print(f"✓ 已生成带元数据文件: {file_path}")
    return file_path


def generate_readme(output_dir, source_file, data_count):
    """生成README.md文件"""
    readme_content = f"""# 职位数据JSON文件说明

## 文件概述

本目录包含从 `{os.path.basename(source_file)}` 转换而来的JSON格式职位数据。

## 文件结构

### 可能包含的文件：

1. **job_data.json** - 包含所有职位数据的完整JSON文件（数组格式）
2. **job_data_with_metadata.json** - 包含职位数据和转换元数据的完整文件
3. **job_0.json, job_1.json, ...** - 单个职位的独立JSON文件

## 数据字段说明

基于Excel表头，每个职位记录包含以下字段：

| 字段名 | 类型 | 说明 |
|--------|------|------|
| job_title_short | string | 职位简称 |
| job_title | string | 完整职位标题 |
| job_location | string | 工作地点 |
| job_via | string | 信息来源 |
| job_schedule_type | string | 工作时间类型（如：Full-time） |
| job_work_from_home | boolean | 是否支持远程工作 |
| search_location | string | 搜索地区 |
| job_posted_date | string | 职位发布日期（YYYY-MM-DD HH:MM:SS格式） |
| job_no_degree_mention | boolean | 是否不要求学位 |
| job_health_insurance | boolean | 是否提供健康保险 |
| job_country | string | 工作国家 |
| salary_rate | string/null | 薪资频率 |
| salary_year_avg | number/null | 年平均薪资 |
| salary_hour_avg | number/null | 小时平均薪资 |
| company_name | string | 公司名称 |
| job_skills | string/null | 职位技能要求（字符串格式的列表） |
| job_type_skills | string/null | 分类技能要求（字符串格式的对象） |

## 转换信息

- **源文件**: {os.path.basename(source_file)}
- **转换时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
- **记录总数**: {data_count}个职位
- **转换脚本**: convert_excel_to_json.py

## 使用建议

1. 如需要所有数据，使用 `job_data.json`
2. 如需要元数据信息，使用 `job_data_with_metadata.json`
3. 如需要处理单个职位，使用对应的 `job_X.json` 文件
4. 注意 `job_skills` 和 `job_type_skills` 字段为字符串格式，使用时可能需要进一步解析

## 重新生成数据

要重新转换数据，运行：
```bash
python convert_excel_to_json.py -f {os.path.basename(source_file)} -o {os.path.basename(output_dir)}
```
"""
    
    readme_path = os.path.join(output_dir, 'README.md')
    with open(readme_path, 'w', encoding='utf-8') as f:
        f.write(readme_content)
    print(f"✓ 已生成说明文档: {readme_path}")


def main():
    parser = setup_args()
    args = parser.parse_args()
    
    # 如果没有提供参数，进入交互式模式
    if not any(vars(args).values()) or (not args.file and not any([args.all, args.complete, args.separate, args.metadata])):
        source_file, output_dir, format_options, generate_readme_flag = interactive_mode()
        if source_file is None:
            return 1
        indent = 2
        no_readme = not generate_readme_flag
    else:
        source_file = args.file or 'data_job.xlsx'
        output_dir = args.output
        format_options = {
            'all': args.all,
            'complete': args.complete, 
            'separate': args.separate,
            'metadata': args.metadata
        }
        # 如果没有指定任何格式，默认生成所有格式
        if not any(format_options.values()):
            format_options['all'] = True
        
        indent = args.indent
        no_readme = args.no_readme
    
    # 检查源文件
    if not os.path.exists(source_file):
        print(f"错误: 源文件 '{source_file}' 不存在！")
        return 1
    
    try:
        print(f"\n开始转换: {source_file}")
        
        # 读取Excel文件
        df = pd.read_excel(source_file)
        print(f"✓ 成功读取Excel文件，共 {len(df)} 条记录")
        
        # 转换数据类型
        df_converted = convert_data_types(df)
        
        # 转换为字典列表
        data = df_converted.to_dict('records')
        column_names = df.columns.tolist()
        
        # 创建输出目录
        os.makedirs(output_dir, exist_ok=True)
        print(f"✓ 输出目录: {output_dir}")
        
        # 根据选择生成文件
        generated_files = []
        
        if format_options.get('all') or format_options.get('complete'):
            file_path = save_complete_data(data, output_dir, indent)
            generated_files.append(file_path)
        
        if format_options.get('all') or format_options.get('separate'):
            file_paths = save_separate_files(data, output_dir, indent)
            generated_files.extend(file_paths)
        
        if format_options.get('all') or format_options.get('metadata'):
            file_path = save_metadata_file(data, source_file, output_dir, column_names, indent)
            generated_files.append(file_path)
        
        # 生成README
        if not no_readme:
            generate_readme(output_dir, source_file, len(data))
        
        print(f"\n🎉 转换完成！共生成 {len(generated_files)} 个JSON文件")
        print(f"输出目录: {os.path.abspath(output_dir)}")
        
        return 0
        
    except Exception as e:
        print(f"❌ 转换失败: {str(e)}")
        return 1


if __name__ == "__main__":
    sys.exit(main()) 